home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Tools / Languages / Caml Light 0.61 / Source / src / yacc / verbose.c < prev    next >
Encoding:
Text File  |  1993-09-24  |  6.2 KB  |  304 lines  |  [TEXT/MPS ]
  1.  rules, %d states\n", nrules - 2, nstates);
  2. }
  3.  
  4.  
  5. log_unused()
  6. {
  7.     register int i;
  8.     register short *p;
  9.  
  10.     fprintf(verbose_file, "\n\nRules never reduced:\n");
  11.     for (i = 3; i < nrules; ++i)
  12.     {
  13.     if (!rules_used[i])
  14.     {
  15.         fprintf(verbose_file, "\t%s :", symbol_name[rlhs[i]]);
  16.         for (p = ritem + rrhs[i]; *p >= 0; ++p)
  17.         fprintf(verbose_file, " %s", symbol_name[*p]);
  18.         fprintf(verbose_file, "  (%d)\n", i - 2);
  19.     }
  20.     }
  21. }
  22.  
  23.  
  24. log_conflicts()
  25. {
  26.     register int i;
  27.  
  28.     fprintf(verbose_file, "\n\n");
  29.     for (i = 0; i < nstates; i++)
  30.     {
  31.     if (SRconflicts[i] || RRconflicts[i])
  32.     {
  33.         fprintf(verbose_file, "State %d contains ", i);
  34.         if (SRconflicts[i] == 1)
  35.         fprintf(verbose_file, "1 shift/reduce conflict");
  36.         else if (SRconflicts[i] > 1)
  37.         fprintf(verbose_file, "%d shift/reduce conflicts",
  38.             SRconflicts[i]);
  39.         if (SRconflicts[i] && RRconflicts[i])
  40.         fprintf(verbose_file, ", ");
  41.         if (RRconflicts[i] == 1)
  42.         fprintf(verbose_file, "1 reduce/reduce conflict");
  43.         else if (RRconflicts[i] > 1)
  44.         fprintf(verbose_file, "%d reduce/reduce conflicts",
  45.             RRconflicts[i]);
  46.         fprintf(verbose_file, ".\n");
  47.     }
  48.     }
  49. }
  50.  
  51.  
  52. print_state(state)
  53. int state;
  54. {
  55.     if (state)
  56.     fprintf(verbose_file, "\n\n");
  57.     if (SRconflicts[state] || RRconflicts[state])
  58.     print_conflicts(state);
  59.     fprintf(verbose_file, "state %d\n", state);
  60.     print_core(state);
  61.     print_nulls(state);
  62.     print_actions(state);
  63. }
  64.  
  65.  
  66. print_conflicts(state)
  67. int state;
  68. {
  69.     register int symbol, act, number;
  70.     register action *p;
  71.  
  72.     symbol = -1;
  73.     for (p = parser[state]; p; p = p->next)
  74.     {
  75.     if (p->suppressed == 2)
  76.         continue;
  77.  
  78.     if (p->symbol != symbol)
  79.     {
  80.         symbol = p->symbol;
  81.         number = p->number;
  82.         if (p->action_code == SHIFT)
  83.         act = SHIFT;
  84.         else
  85.         act = REDUCE;
  86.     }
  87.     else if (p->suppressed == 1)
  88.     {
  89.         if (state == final_state && symbol == 0)
  90.         {
  91.         fprintf(verbose_file, "%d: shift/reduce conflict \
  92. (accept, reduce %d) on $end\n", state, p->number - 2);
  93.         }
  94.         else
  95.         {
  96.         if (act == SHIFT)
  97.         {
  98.             fprintf(verbose_file, "%d: shift/reduce conflict \
  99. (shift %d, reduce %d) on %s\n", state, number, p->number - 2,
  100.                 symbol_name[symbol]);
  101.         }
  102.         else
  103.         {
  104.             fprintf(verbose_file, "%d: reduce/reduce conflict \
  105. (reduce %d, reduce %d) on %s\n", state, number - 2, p->number - 2,
  106.                 symbol_name[symbol]);
  107.         }
  108.         }
  109.     }
  110.     }
  111. }
  112.  
  113.  
  114. print_core(state)
  115. int state;
  116. {
  117.     register int i;
  118.     register int k;
  119.     register int rule;
  120.     register core *statep;
  121.     register short *sp;
  122.     register short *sp1;
  123.  
  124.     statep = state_table[state];
  125.     k = statep->nitems;
  126.  
  127.     for (i = 0; i < k; i++)
  128.     {
  129.     sp1 = sp = ritem + statep->items[i];
  130.  
  131.     while (*sp >= 0) ++sp;
  132.     rule = -(*sp);
  133.     fprintf(verbose_file, "\t%s : ", symbol_name[rlhs[rule]]);
  134.  
  135.         for (sp = ritem + rrhs[rule]; sp < sp1; sp++)
  136.         fprintf(verbose_file, "%s ", symbol_name[*sp]);
  137.  
  138.     putc('.', verbose_file);
  139.  
  140.     while (*sp >= 0)
  141.     {
  142.         fprintf(verbose_file, " %s", symbol_name[*sp]);
  143.         sp++;
  144.     }
  145.     fprintf(verbose_file, "  (%d)\n", -2 - *sp);
  146.     }
  147. }
  148.  
  149.  
  150. print_nulls(state)
  151. int state;
  152. {
  153.     register action *p;
  154.     register int i, j, k, nnulls;
  155.  
  156.     nnulls = 0;
  157.     for (p = parser[state]; p; p = p->next)
  158.     {
  159.     if (p->action_code == REDUCE &&
  160.         (p->suppressed == 0 || p->suppressed == 1))
  161.     {
  162.         i = p->number;
  163.         if (rrhs[i] + 1 == rrhs[i+1])
  164.         {
  165.         for (j = 0; j < nnulls && i > null_rules[j]; ++j)
  166.             continue;
  167.  
  168.         if (j == nnulls)
  169.         {
  170.             ++nnulls;
  171.             null_rules[j] = i;
  172.         }
  173.         else if (i != null_rules[j])
  174.         {
  175.             ++nnulls;
  176.             for (k = nnulls - 1; k > j; --k)
  177.             null_rules[k] = null_rules[k-1];
  178.             null_rules[j] = i;
  179.         }
  180.         }
  181.     }
  182.     }
  183.  
  184.     for (i = 0; i < nnulls; ++i)
  185.     {
  186.     j = null_rules[i];
  187.     fprintf(verbose_file, "\t%s : .  (%d)\n", symbol_name[rlhs[j]],
  188.         j - 2);
  189.     }
  190.     fprintf(verbose_file, "\n");
  191. }
  192.  
  193.  
  194. print_actions(stateno)
  195. int stateno;
  196. {
  197.     register action *p;
  198.     register shifts *sp;
  199.     register int as;
  200.  
  201.     if (stateno == final_state)
  202.     fprintf(verbose_file, "\t$end  accept\n");
  203.  
  204.     p = parser[stateno];
  205.     if (p)
  206.     {
  207.     print_shifts(p);
  208.     print_reductions(p, defred[stateno]);
  209.     }
  210.  
  211.     sp = shift_table[stateno];
  212.     if (sp && sp->nshifts > 0)
  213.     {
  214.     as = accessing_symbol[sp->shift[sp->nshifts - 1]];
  215.     if (ISVAR(as))
  216.         print_gotos(stateno);
  217.     }
  218. }
  219.  
  220.  
  221. print_shifts(p)
  222. register action *p;
  223. {
  224.     register int count;
  225.     register action *q;
  226.  
  227.     count = 0;
  228.     for (q = p; q; q = q->next)
  229.     {
  230.     if (q->suppressed < 2 && q->action_code == SHIFT)
  231.         ++count;
  232.     }
  233.  
  234.     if (count > 0)
  235.     {
  236.     for (; p; p = p->next)
  237.     {
  238.         if (p->action_code == SHIFT && p->suppressed == 0)
  239.         fprintf(verbose_file, "\t%s  shift %d\n",
  240.                 symbol_name[p->symbol], p->number);
  241.     }
  242.     }
  243. }
  244.  
  245.  
  246. print_reductions(p, defred)
  247. register action *p;
  248. register int defred;
  249. {
  250.     register int k, anyreds;
  251.     register action *q;
  252.  
  253.     anyreds = 0;
  254.     for (q = p; q ; q = q->next)
  255.     {
  256.     if (q->action_code == REDUCE && q->suppressed < 2)
  257.     {
  258.         anyreds = 1;
  259.         break;
  260.     }
  261.     }
  262.  
  263.     if (anyreds == 0)
  264.     fprintf(verbose_file, "\t.  error\n");
  265.     else
  266.     {
  267.     for (; p; p = p->next)
  268.     {
  269.         if (p->action_code == REDUCE && p->number != defred)
  270.         {
  271.         k = p->number - 2;
  272.         if (p->suppressed == 0)
  273.             fprintf(verbose_file, "\t%s  reduce %d\n",
  274.                 symbol_name[p->symbol], k);
  275.         }
  276.     }
  277.  
  278.         if (defred > 0)
  279.         fprintf(verbose_file, "\t.  reduce %d\n", defred - 2);
  280.     }
  281. }
  282.  
  283.  
  284. print_gotos(stateno)
  285. int stateno;
  286. {
  287.     register int i, k;
  288.     register int as;
  289.     register short *to_state;
  290.     register shifts *sp;
  291.  
  292.     putc('\n', verbose_file);
  293.     sp = shift_table[stateno];
  294.     to_state = sp->shift;
  295.     for (i = 0; i < sp->nshifts; ++i)
  296.     {
  297.     k = to_state[i];
  298.     as = accessing_symbol[k];
  299.     if (ISVAR(as))
  300.         fprintf(verbose_file, "\t%s  goto %d\n", symbol_name[as], k);
  301.     }
  302. }
  303.  
  304.